#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

// 定义区间结构体
struct Interval {
    ll start, end;
    // 定义区间的比较规则，用于有序集合中的排序
    bool operator<(const Interval& other) const {
        return start < other.start;
    }
};

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    ll N, Q;
    cin >> N >> Q;
    vector<ll> A(N);
    for(auto &x : A) cin >> x; // 读取每个雪球的初始位置
    vector<ll> W(Q);
    for(auto &x : W) cin >> x; // 读取每天的风力强度
    
    // 计算累计位移
    vector<ll> C(Q+1, 0);
    for(int j=1; j<=Q; ++j){
        C[j] = C[j-1] + W[j-1];
    }
    
    // 初始化被雪覆盖的区间。为了避免无穷大，选择一个足够大的初始区间
    set< pair<ll, ll> > snow;
    snow.emplace(-LLONG_MAX/2, LLONG_MAX/2); // 初始时数轴被完全覆盖
    
    // 初始化每个雪球的质量为0
    vector<ll> mass(N, 0);
    
    // 逐天处理风力影响
    for(int j=1; j<=Q; ++j){
        ll shift = W[j-1];
        // 如果风力为0，则雪球不移动，跳过当天
        if(shift == 0){
            continue;
        }
        
        // 判断风力方向，正数为向右，负数为向左
        // bool right = shift > 0;
        
        // 遍历所有雪球，计算每个雪球当天的移动路径
        for(int i=0; i<N; ++i){
            ll old_pos = A[i] + C[j-1]; // 前一天的位置
            ll new_pos = A[i] + C[j];   // 今天之后的位置
            ll L = min(old_pos, new_pos); // 移动路径的左端点
            ll R = max(old_pos, new_pos); // 移动路径的右端点
            
            // 查找所有与移动路径 [L, R] 重叠的被雪覆盖区间
            auto it = snow.lower_bound({L, -LLONG_MAX});
            if(it != snow.begin()){
                --it;
            }
            
            // 存储需要移除和添加的区间
            vector<pair<ll, ll>> to_remove;
            vector<pair<ll, ll>> to_add;
            ll total = 0; // 统计当前雪球当天获得的质量
            
            auto itr = it;
            while(itr != snow.end()){
                if(itr->first > R) break; // 当前区间的起点已经超过移动路径的右端点，结束查找
                if(itr->second < L){
                    ++itr;
                    continue; // 当前区间的右端点在移动路径的左端点左边，继续下一个区间
                }
                // 存在重叠
                ll overlap_L = max(L, itr->first); // 重叠区间的左端点
                ll overlap_R = min(R, itr->second); // 重叠区间的右端点
                if(overlap_L < overlap_R){
                    total += (overlap_R - overlap_L); // 累加重叠部分的长度到雪球的质量
                    // 将重叠部分从被雪覆盖区间中移除
                    to_remove.emplace_back(*itr);
                    if(itr->first < overlap_L){
                        to_add.emplace_back(make_pair(itr->first, overlap_L)); // 添加左侧未被覆盖的部分
                    }
                    if(overlap_R < itr->second){
                        to_add.emplace_back(make_pair(overlap_R, itr->second)); // 添加右侧未被覆盖的部分
                    }
                }
                ++itr;
            }
            // 执行区间的移除和添加
            for(auto &[s,e] : to_remove){
                snow.erase({s,e});
            }
            for(auto &[s,e] : to_add){
                snow.emplace(s,e);
            }
            // 更新当前雪球的质量
            mass[i] += total;
        }
    }
    
    // 输出每个雪球的最终质量
    for(auto x : mass){
        cout << x << "\n";
    }
}
